Section 1

Premiers pas concrets dans PowerShell

Retour à la page du cours

L'installation

Si vous êtes un utilisateur de Windows 7, vous possédez déjà la version 2.0 de PowerShell.

Si vous utilisez Windows 2008, vous pouvez installer PowerShell 1.0 à partir du CD d'installation de Windows 2008 (si ce n'est déjà fait) ou télécharger la version 2.0 pour service pack 1 ou 2.

Si vous avez Windows Vista Business, Enterprise ou Ultimate, vous pouvez télécharger la version 1.0. Vous pouvez également télécharger la version 2.0 pour n'importe quelle édition de Vista, pour service pack 1 ou 2, sous forme de mise à jour du système.

Si vous avez Windows 2003, vous pouvez télécharger PowerShell 1.0. Si vous avez le service pack 2, vous pouvez télécharger la version 2.0.

Si vous avez Windows XP, vous pouvez télécharger PowerShell 1.0 à partir du service pack 2 et la version 2.0 à partir du service pack 3.

Si vous avez une autre version de Windows, bienvenue au 21e siècle. Si vous utilisez Linux, vous n'êtes pas dans le bon cours - on couvrira les scripts Linux en session 4!

Dans notre laboratoire

Comme nous travaillons au P-113, sur des PC équipés de Windows XP sur lesquels nous n'avons pas les droits d'administrateur, nous allons donc nous créer une machine virtuelle pour y installer PowerShell.

Vous disposez d'une image du CD d'installation de Windows XP (quelque part sur le disque C:) pour votre machine virtuelle. Il n'est pas du tout certain que cette image contienne le service pack 3 et si ce n'est pas le cas, son installation sera complexifiée par le fait que nous ne pourrons pas enregistrer cette version (on fonctionnera avec le démo de 60 jours qui couvre amplement notre session). Si tel est le cas, il sera donc plus simple d'installer PowerShell 1.0 - comme nous n'irons pas en profondeur dans ses fonctionnalités avec notre maigre 45 heures, vous ne verez de toute façon pas la différence.

L'environnement PowerShell

PowerShell s'ouvre comme une fenêtre console très similaire à la console cmd.exe, mais plus large, bleue et avec des caractères blancs.

Un prompt (invite de commande) vous est affiché. Cette invite est composée des lettres "PS", du chemin du répertoire courant (vous devriez avoir déjà constaté que ce n'est pas toujours un répertoire réel), puis du symbole ">". Vous pouvez y taper des commandes (vous devriez déjà connaître get-help, get-command et get-service, entre autres) et l'interface réagit en les exécutant et en vous affichant le résultat. Gardez en mémoire qu'en fait, le résultat de ces commandes n'est pas du texte, mais un objet contenant du texte, qui est formaté par défaut puis affiché. Il est possible, on le verra, de modifier ce formatage.

Les scripts

Pour exécuter un script, il suffit d'en créer un dans un bête fichier texte et de changer son extension en .ps1. Vous pourrez ensuite l'exécuter dans PowerShell en l'appelant par son nom. (Notez que si vous disposez de PowerShell 2.0, vous pouvez démarrer le PowerShell ISE (Integrated Scripting Environment) qui vous permet d'éditer un script et de le tester directement.)

Il faut savoir deux choses importantes pour exécuter nos scripts:

1. PowerShell ne vérifie jamais dans le répertoire courant si un script est présent lorsque l'on tente de l'exécuter. Vous devrez donc toujours taper un chemin complet. Toutefois, les chemins relatifs sont permis alors on peut faire quelque chose comme: .\test.ps1
2. Par défaut, PowerShell ne permet pas l'exécution de scripts, par mesure de sécurité. Tout dépend de votre execution policy (politique d'exécution).

   1. get-executionpolicy permet de vérifier laquelle vous avez ("Restricted" par défaut).
   2. set-executionpolicy suivi d'un paramètre permet de la modifier (les choix possibles sont "Restricted", "AllSigned", "RemoteSigned" et "Unrestricted"
      1. Attention! Si vous utilisez Vista ou 7, vous devrez démarrer PowerShell en tant qu'administrateur pour que set-executionpolicy puisse fonctionner!

Les variables

• Un nom de variable commence toujours par un "$". On l'utilise chaque fois qu'on utilise la variable, que ce soit pour y placer quelque chose ou pour lire son contenu.
• Si votre variable contient des caractères spéciaux (comme le "-" ou un espace), placez son nom entre accolades: ${ma-variable}
• Si votre variable contient des accolades, placez-la entre accolades et précédez les accolades faisant partie du nom d'un `(backtick ou accent grave): ${voici`{une`}variable}
• On assigne une valeur à une variable ainsi: $variable = valeur
• La valeur peut être un nombre, du texte (entre guillemets), un booléen ou une liste de valeurs séparées par des virgules (la liste peut contenir des valeurs de types différents).

  • Lorsque l'on assigne une liste à une variable ($variable = 1, 45, "allo"), on peut ensuite accéder à une des valeurs de la liste en utilisant un index de 0 à x entre crochets ($variable[1]).
  • Notez que l'on peut aussi faire ceci: $variable[0] = "coucou"
  • Les valeurs booléennes vrai/faux s'écrivent $true et $false. Ce sont elles-mêmes des variables qui contiennent les "vraies" valeurs booléennes, que seul le système peut manipuler.
• Il est possible d'incrémenter une variable numérique de 1 en utilisant l'opérateur ++ de cette façon: $nombre++ (ceci est équivalent à $nombre = $nombre + 1)
• On peut appliquer le même principe à la décrémentation avec l'opérateur --
• Écrire simplement $variable comme une commande affiche le contenu de la variable.
• On n'a pas besoin de déclarer une variable avant de l'utiliser.
• La variable reste valide tout au long de la session, mais pas plus longtemps (pour rendre une variable "permanente", il faudra l'ajouter à notre profil (ce qu'on verra plus tard)).
• Il existe déjà plusieurs variables prédéfinies - certaines que l'on peut modifier (contenant nos préférences) et d'autres non (contenant l'état du système).
• get-variable utilisé seul permet de lister les variables présentement définies.
• get-variable suivi du nom d'une variable permet de recevoir un objet englobant la variable (et donc de l'afficher).
• cd variable: permet d'accéder à l'emplacement des variables, comme si c'était un disque!

Lecture et écriture à la console

La console s'appelle "Host" et les fonctions/applets de commande suivants existent:

• Write-Host permet d'écrire: Write-Host "Bonjour les amis!" (notez que les guillemets sont facultatifs)
• Read-Host permet d'afficher un message à l'écran et de saisir la réponse du clavier: $nom = Read-Host "Veuillez entrer votre nom"
• Clear-Host vide la console
• Write-Error permet d'écrire un message sous forme de message d'erreur! Write-Error "Attention, vous allez tout briser!"
• Ne vous gênez pas pour aller chercher de l'aide sur ces commandes, elles offrent beaucoup de possibilités!

Les alternatives

• La structure if existe évidemment en PowerShell, mais sa syntaxe est calquée sur celle de C# (et donc pas sur celle de VB.NET). Les différences sont mineures:

  if (<condition 1>)
  {
      <liste d'instructions 1>
  }
  [elseif (<condition 2>)
   {
      <liste d'instructions 2>
   }]
  [else
   {
      <liste d'instructions 3>
   }]

  • Les conditions sont entre parenthèses
  • Les blocs d'instructions sont entre accolades (obligatoire!)
  • Le elseif est facultatif (et il peut y en avoir plusieurs)
  • Le else est facultatif (mais il ne peut pas y en avoir plus d'un)
  • La structure a un seul point de sortie - au plus un bloc d'instructions sera exécuté

• Les conditions sont normalement faites avec des opérateurs de comparaison. Ces opérateurs commencent par un tiret suivi d'un mot (ou d'une abréviation):

  • -eq = égal (equal)
  • -ne = non-égal (not equal)
  • -lt = plus petit que (lesser than)
  • -le = plus petit ou égal (lesser or equal)
  • -gt = plus grand que (greater than)
  • -ge = plus grand ou égal (greater or equal)
  • -like = comme (permet de comparer avec le caractère générique "*")
  • -notlike = pas comme (l'inverse)
  • -contains = contient (permet de vérifier si une liste contient une valeur)
  • -notcontains = ne contient pas (l'inverse)
• Les opérateurs logiques permettent d'unir plusieurs conditions pour obtenir un seul résultat global. Ils fonctionnent de façon très similaire à leurs équivalents VB.NET:

  • -and = et (deux vrais = vrai, sinon c'est faux)
  • -or = ou (deux faux = faux, sinon c'est vrai)
  • -not = non (inverse le résultat du test)
  • ! = non (une autre syntaxe)

Les répétitives

• Les formes do/while et do/until existent en PowerShell, mais encore une fois, leur syntaxe se rapproche de celle du C#:

  do 
  {
     <liste d'instructions>
  } 
  while (<condition>)
  
  do 
  {
     <liste d'instructions>
  } 
  until (<condition>)
  
  while (<condition>) 
  {
     <liste d'instructions>
  }

  • Les blocs d'instructions sont entre accolades
  • Les conditions sont entre parenthèses et sont bâties comme pour le if
  • On peut commencer une boucle par while ou par do selon si on veut que la condition soit évaluée en entrant ou en sortant de la boucle.
  • Le until ne peut pas être placé au début - on devra se résoudre à inverser notre condition si c'est ce qu'on veut faire.
• Les boucles for existent également:

  for (<initialisation>; <condition>; <répétition>)
  {
      <liste d'instructions>
  } 

  • La syntaxe du for est bien différente de celle de VB.NET. Elle offre beaucoup plus de flexibilité en ne faisant pas nécessairement que varier un compteur d'une borne à une autre. Toutefois, dans le cadre de ce cours, nous n'irons pas beaucoup plus loin.
  • Un for est suivi de trois sections séparées par des point-virgules, le tout entre parenthèses.
  • La liste d'instructions à exécuter est entre accolades.
  • La partie initialisation contient les instructions à exécuter lorsqu'on entre dans la boucle la première fois. Généralement, il s'agit simplement d'une initialisation d'une variable compteur.
  • La condition représente la condition pour rester dans la boucle. À chaque tour, elle est évaluée. Si elle est vraie, on fait un tour de plus. Sinon, on quitte.
  • La répétition contient des instructions à exécuter à chaque fois que la boucle a fait un tour. Généralement, on y placera là une modification à la variable compteur.
  • Par exemple:

  for ($i=1; i -le 10; i++)
  {
      Write-host $i
  }

• Les boucles foreach existent aussi (mais il est fort probable que vous ne les ayez pas vu en VB.NET). Très puissantes et simples à utiliser, elles permettent de parcourir aisément une collection afin d'accéder une à une à chacune de ses valeurs.

foreach ($<élément> in <collection>)
{
    <liste d'instructions>
} 

• La première collection qui vient à l'esprit est une liste dans une variable:

$liste = "a", "b", "c", "d"
foreach ($lettre in $liste)
{
    Write-Host $lettre
}           

• Mais le foreach est extrêmement pratique en PowerShell parce que beaucoup de fonctions retournent une collection d'objets, qu'on peut ensuite parcourir un à un. Par exemple, get-childitem retourne une collection d'objets, chacun d'eux contenant un "enfant" de la position courante (le répertoire courant, disons).

foreach ($fichier in get-childitem)
{
    Write-Host $fichier
}